home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 2: CDPD 1 / Almathera Ten on Ten - Disc 2: CDPD 1.iso / pd / 201-225 / 217 / snipit / reco.c < prev    next >
C/C++ Source or Header  |  1995-03-13  |  6KB  |  261 lines
  1. /* :ts=4
  2.  *
  3.  * Amiga SnipIt 1.2
  4.  * (c) (opyright 1987,1988 - Scott Evernden - All Rights Reserved
  5.  *
  6.  * reco.c - recognize & construct char code input
  7.  *
  8.  */
  9.  
  10. #include "hs.h"
  11.  
  12. char *_AllocMem();
  13.  
  14. /* ascii to keycode (this is a hack; is there a correct way to do this?) */
  15. char table[] = {
  16. /*             !     "     #     $     %     &     '  */
  17. /*       (     )     *     +     ,     -     .     /  */
  18. /*     0     1     2     3     4     5     6     7  */
  19. /*     8     9     :     ;     <     =     >     ?  */
  20. /*     @     A     B     C     D     E     F     G  */
  21. /*     H     I     J     K     L     M     N     O  */
  22. /*     P     Q     R     S     T     U     V     W  */
  23. /*     X     Y     Z     [     \     ]     ^     _  */
  24. /*     `     a     b     c     d     e     f     g  */
  25. /*     h     i     j     k     l     m     n     o  */
  26. /*     p     q     r     s     t     u     v     w  */
  27. /*     x     y     z     {     |     }     ~        */
  28.     0x40, 0x81, 0xAA, 0x83, 0x84, 0x85, 0x87, 0x2A,
  29.     0x89, 0x8A, 0x88, 0x8C, 0x38, 0x0B, 0x39, 0x3A,
  30.     0x0A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  31.     0x08, 0x09, 0xA9, 0x29, 0xB8, 0x0C, 0xB9, 0xBA,
  32.     0x82, 0xA0, 0xB5, 0xB3, 0xA2, 0x92, 0xA3, 0xA4,
  33.     0xA5, 0x97, 0xA6, 0xA7, 0xA8, 0xB7, 0xB6, 0x98,
  34.     0x99, 0x90, 0x93, 0xA1, 0x94, 0x96, 0xB4, 0x91,
  35.     0xB2, 0x95, 0xB1, 0x1A, 0x0D, 0x1B, 0x86, 0x8B,
  36.     0x00, 0x20, 0x35, 0x33, 0x22, 0x12, 0x23, 0x24,
  37.     0x25, 0x17, 0x26, 0x27, 0x28, 0x37, 0x36, 0x18,
  38.     0x19, 0x10, 0x13, 0x21, 0x14, 0x16, 0x34, 0x11,
  39.     0x32, 0x15, 0x31, 0x9A, 0x8D, 0x9B, 0x80
  40. };
  41.  
  42. static struct InputEvent event;
  43. char *evs, *evp;
  44. char preString[PRE_SIZE + 1] = "> ";    /* a prestring */
  45. int evslen;
  46.  
  47. extern struct IOStdReq *inpReq;
  48. extern struct TextFont *capttf;
  49. extern struct BitMap captbm;
  50. extern int captx, capty;
  51. extern int charx, chary;
  52. extern int left, right;
  53. extern int cmd1, cmd2, jobFlag;
  54.  
  55. /*********************************************/
  56.  
  57. /* cleanup, local to this module */
  58. finiReco()
  59. {
  60.     /* event string is allocated */
  61.     if (evs)
  62.         _FreeMem(evs, (long) evslen);
  63. }
  64.  
  65. /*********************************************/
  66.  
  67. /* entry to recognizer; generates keycode events from the capture bitmap */
  68. buildEvents()
  69. {
  70.     register char *cp;
  71.     PLANEPTR p;
  72.     int code;
  73.  
  74.     /* prepare request to input device */
  75.     inpReq->io_Command = IND_WRITEEVENT;
  76.     inpReq->io_Flags = 0;
  77.     inpReq->io_Length = sizeof (struct InputEvent);
  78.     inpReq->io_Data = (APTR) &event;
  79.  
  80.     /* new snip-map? */
  81.     if (capttf) {
  82.  
  83.         /* new buffer for keycodes */
  84.         if (evs)
  85.             _FreeMem(evs, (long) evslen);
  86.  
  87.         evslen = (captx / charx) * (capty / chary);
  88.         evs = (char *) _AllocMem((long) evslen, 0L);
  89.  
  90.         if (evp = evs)
  91.             buildCodes();
  92.  
  93.         capttf = NULL;        /* reset "newly-captured" indicator */
  94.  
  95.         /* reco'ed, so drop the bitmap */
  96.         if (p = captbm.Planes[0]) {
  97.             FreeRaster(p, (long) captx, (long) capty);
  98.             captbm.Planes[0] = NULL;
  99.         }
  100.     }
  101.     else if (evp = evs) {
  102.  
  103.         while (*evp != -1) {
  104.  
  105.             if (jobFlag & cmd2) {
  106.                 cp = preString;
  107.                 while (*cp)
  108.                     sendKey(*cp++);
  109.             }
  110.  
  111.             do
  112.                 sendKey(code = *evp++);
  113.             while (code != '\n' && *evp != -1);
  114.         }
  115.     }
  116. }
  117.  
  118. /*********************************************/
  119.  
  120. /* inject a (fake) keyboard press/release into the input stream */
  121. sendKey(code)
  122. int code;
  123. {
  124.     /* convert to raw key */
  125.     code = code == '\n' ? 0x44 : table[code - 32];
  126.  
  127.     /* build key down event */
  128.     event.ie_Class = IECLASS_RAWKEY;
  129.     event.ie_Code = code & 0x7F;
  130.     event.ie_Qualifier = IEQUALIFIER_RELATIVEMOUSE;
  131.     if (code & 0x80)
  132.         event.ie_Qualifier |= IEQUALIFIER_LSHIFT;
  133.     event.ie_NextEvent = NULL;
  134.  
  135.     /* make it happen */
  136.     DoIO(inpReq);
  137.  
  138.     /* build key up event (req'd?) */
  139.     event.ie_Class = IECLASS_RAWKEY;
  140.     event.ie_Code = (code & 0x7F) | IECODE_UP_PREFIX;
  141.     event.ie_Qualifier = IEQUALIFIER_RELATIVEMOUSE;
  142.     if (code & 0x80)
  143.         event.ie_Qualifier |= IEQUALIFIER_LSHIFT;
  144.     event.ie_NextEvent = NULL;
  145.  
  146.     /* make it happen */
  147.     DoIO(inpReq);
  148. }
  149.  
  150. /*********************************************/
  151.  
  152. /* actually makes the keycodes */
  153. buildCodes()
  154. {
  155.     register int code, px, py, wid, lastx, lasty, spaces;
  156.     char *cp;
  157.  
  158.     /* heuristics for text structure (i.e., newlines) */
  159.     px = left;
  160.     py = 0;
  161.     lastx = captx / charx - 1;
  162.     lasty = capty / chary - 1;
  163.     wid = lastx;
  164.  
  165.     while (py <= lasty) {
  166.  
  167.         /* prestring on cmd2 key */
  168.         if (jobFlag & cmd2) {
  169.             cp = preString;
  170.             while (*cp)
  171.                 sendKey(*cp++);        /* don't record */
  172.         }
  173.  
  174.         /* on the last line? */
  175.         if (py == lasty)
  176.             lastx = right;
  177.  
  178.         /* for each cell... */
  179.         while (px <= lastx) {
  180.  
  181.             /* recognize single character */
  182.             code = reco(px++, py);
  183.  
  184.             /* we're gonna count runs of spaces */
  185.             spaces = 0;
  186.             while (code == ' ' && px <= wid) {
  187.                 spaces++;
  188.                 code = reco(px++, py);
  189.             }
  190.  
  191.             /* send / record, if no spaces */
  192.             if (!spaces)
  193.                 sendKey(*evp++ = code);
  194.  
  195.             /* if end of line is all spaces, then regard as newline */
  196.             else if (code == ' ' && wid < px)
  197.                 sendKey(*evp++ = '\n');
  198.  
  199.             /* if more text on line after snip area, then not a newline */
  200.             else if (py < lasty || px <= lastx + 1) {
  201.                 while (spaces--)
  202.                     sendKey(*evp++ = ' ');
  203.                 sendKey(*evp++ = code);
  204.             }
  205.  
  206.             /* emit spaces */
  207.             else {
  208.                 spaces -= px - lastx - 2;
  209.                 while (spaces--)
  210.                     sendKey(*evp++ = ' ');
  211.             }
  212.         }
  213.  
  214.         /* next is leftside of next row down */
  215.         px = 0;
  216.         py++;
  217.     }
  218.  
  219.     *evp = -1;        /* record terminator */
  220. }
  221.  
  222. /*********************************************/
  223.  
  224. /* return ascii code of character in capture bitmap at (x,y) */
  225. int reco(x, y)
  226. int x, y;
  227. {
  228.     register char *s, *d, *sp, *dp;
  229.     register int hyt, i;
  230.  
  231.     /* recognize cell at (x,y) */
  232.     sp = (char *) capttf->tf_CharData;
  233.     dp = (char *) captbm.Planes[0] + y * chary * captbm.BytesPerRow + x;
  234.  
  235.     for (i = 32; i < 128; sp++, i++) {
  236.         s = sp;
  237.         d = dp;
  238.         hyt = capttf->tf_YSize;
  239.  
  240.         if (*s == *d) {
  241.             do {
  242.                 if (--hyt == 0)
  243.                     return i;
  244.                 s += capttf->tf_Modulo;
  245.                 d += captbm.BytesPerRow;
  246.             } while (*s == *d);
  247.         }
  248.         else if (*s == ~*d) {
  249.             do {
  250.                 if (--hyt == 0)
  251.                     return i;
  252.                 s += capttf->tf_Modulo;
  253.                 d += captbm.BytesPerRow;
  254.             } while (*s == ~*d);
  255.         }
  256.     }
  257.  
  258.     return '?';    /* unknown */
  259. }
  260.  
  261.